package com.biyesheji.controller;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.biyesheji.common.BaseContext;
import com.biyesheji.common.R;
import com.biyesheji.domain.*;
import com.biyesheji.dto.WaresDto;
import com.biyesheji.service.IBusinessService;
import com.biyesheji.service.IEmployeeService;
import com.biyesheji.service.IOrdersService;
import com.biyesheji.service.IWaresService;
import com.biyesheji.utils.MapDistance1;
import com.biyesheji.utils.OrdersTime;
import com.biyesheji.utils.ValidateCodeUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.DigestUtils;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * <p>
 * 用户信息 前端控制器
 * </p>
 *
 * @author 崔
 * @since 2023-02-12
 */
@Slf4j
@RestController
@RequestMapping("/business")
public class BusinessController {


    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private IBusinessService businessService;

    @Autowired
    private IWaresService waresService;

    @Autowired
    private IOrdersService ordersService;


    /*
     *    发送手机短信验证码
     * */
    @PostMapping("/sendMsg")
    public R<String> sendMsg(@RequestBody Business business, HttpSession session){

        System.out.println("发短信运行了！！");

        // 获取手机号
        String phone = business.getPhone();

        if (StringUtils.isNotEmpty(phone)){

            // 生成随机的4位验证码
            String code = ValidateCodeUtils.generateValidateCode(4).toString();

            // 模拟手机短信验证码发送，在控制台看输出结果，得到验证码
            log.info("code={}", code);

             /*调用阿里云提供的短信服务 API 完成发送短信,因为在阿里云注册短信麻烦,需要企业营业等的质料，
             目前未达到要求，所以用日志输出模拟以下就好，下面就是发送短信验证码的代码，需要配合阿里云的短信服务*/
//            SMSUtils.sendMessage("短信签名","短信模板code", phone, code);

            // 需要将生成的验证码保存到 Session
//            session.setAttribute(phone, code);

            // 将生成的验证码缓存到 Redis 中, 并且设置有效期为 5 分钟
            redisTemplate.opsForValue().set("business_"+phone, code, 5, TimeUnit.MINUTES);


//            return R.success("短信发送成功,小花的验证码为： " + code);
            return R.success("短信发送成功,你的验证码为： " + code);
        }

        return R.error("短信发送失败");
    }



    /*
     *     商家登录
     * */
    @PostMapping("/login")
    public R<Business> login(@RequestBody Map map, HttpSession session){
        log.info(map.toString());

        //  获取手机号
        String phone = map.get("phone").toString();

        // 获取验证码
        String code = map.get("code").toString();

        // 获取密码
        String password = map.get("password").toString();

        // 从 Session 中获取保存的验证码
//        Object codeInSession = session.getAttribute(phone);


        // 从 Redis 中获取缓存的验证码
        Object codeInSession = redisTemplate.opsForValue().get("business_"+phone);



        // 进行验证码的比对(页面提交的验证码和 Session 中保存的验证码比对)
        if (codeInSession != null && codeInSession.equals(code)) {
            // 如果能够比对成功，说明登录成功

            LambdaQueryWrapper<Business> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(Business::getPhone, phone);

            Business business = businessService.getOne(queryWrapper);

            if (business == null) {
                // 判断当前手机号对应的用户是否为新用户，如果是新用户就自动完成注册
/*                business = new business();
                business.setPhone(phone);
                business.setStatus(1);
                businessService.save(business);  */
                return R.error("该员工不存在");

            } else {

                //  1、 将页面提交的密码 password 进行 md5 加密处理
                password = DigestUtils.md5DigestAsHex(password.getBytes());

                //  4、 密码比对，如果不一致则返回登录失败结果
                if (!business.getPassword().equals(password)){
                    return  R.error("密码错误，登录失败");
                }

                //  5、 查看员工状态，如果为已禁用状态，则返回员工已禁用结果
                if (business.getStatus() == 0) {
                    return R.error("该账号已禁用");
                }
            }

            session.setAttribute("business", business.getId());

            // 如果用户登录成功, 删除 Redis 中缓存的验证码
            redisTemplate.delete(phone);

            return R.success(business);
        }

        return R.error("登录失败");
    }


    /*
     *     商家申请注册
     * */
    @PostMapping("/register")
    public R<String> register(@RequestBody Map map){
        log.info(map.toString());

        //  获取手机号
        String phone = map.get("phone").toString();

        // 获取验证码
        String code = map.get("code").toString();

        // 获取密码
        String password = map.get("password").toString();

        // 从 Session 中获取保存的验证码
//        Object codeInSession = session.getAttribute(phone);


        // 从 Redis 中获取缓存的验证码
        Object codeInSession = redisTemplate.opsForValue().get("business_"+phone);



        // 进行验证码的比对(页面提交的验证码和 Session 中保存的验证码比对)
        if (codeInSession != null && codeInSession.equals(code)) {
            // 如果能够比对成功，说明登录成功


            LambdaQueryWrapper<Business> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(Business::getPhone, phone);

            Business business1 = businessService.getOne(queryWrapper);

            if(business1 != null){

                return R.error("该账号已存在, 申请失败");
            }



            Business business = new Business();

            business.setStatus(2);
            password = DigestUtils.md5DigestAsHex(password.getBytes());
            business.setPassword(password);
            business.setPhone(phone);

            boolean save = businessService.save(business);

            if (save) {

                // 如果用户登录失败, 删除 Redis 中缓存的验证码
                redisTemplate.delete(phone);
                return R.success("申请成功");

            } else {

                // 如果用户登录失败, 删除 Redis 中缓存的验证码
                redisTemplate.delete(phone);
                return R.error("申请失败");
            }

        }

        return R.error("验证码错误，申请失败");
    }



    /*
     *    商家退出
     * */
    @GetMapping("/loginout")
    public R<String> loginout(HttpServletRequest request){

        // 清理 Session 中保存的当前登录商家的 id
        request.getSession().removeAttribute("business");

        System.out.println("商家退出登录运行了");

        return R.success("退出成功");
    }




    /*
     *     查询商品民宿信息
     * */
    @GetMapping("/getWares")
    public R<List> getWares(String waresName, Integer status) {


        System.out.println(" waresName 得到的数据是：  " + waresName);
        System.out.println(" status 得到的数据是：  " + status);

        if (status == 4){

            status = null;
        }

        long businessId = BaseContext.getCurrentId();

        Business business = businessService.getById(businessId);


        // 根据输入的条件得到民宿 Wares 的集合
        List<Wares> waresList = waresService.getWares3(null, waresName,  null, null, null, null, null, Long.valueOf(business.getPhone()), status);

        for (int i = 0; i < waresList.size(); i++) {

            waresList.get(i).setImage("/common/download?name=" + waresList.get(i).getImage());
        }


        return R.success(waresList);
    }




    /*
     *     修改订单状态为 0
     *     停售
     * */
    @PutMapping("/updateWares")
    public R<String> updateWares(@RequestBody Wares wares) throws ParseException {

        System.out.println("wares 的数据是：   " + wares);
        Boolean aBoolean = waresService.updateWaresStatus(wares);
        if (aBoolean){
            return R.success("修改成功");
        }

        return R.success("修改失败");
    }


    /*
     *     申请商品
     *
     * */
    @PostMapping("/saveWares")
    public R<String> saveWares(@RequestBody Wares wares) throws ParseException {

        System.out.println("wares 的数据是：   " + wares);

        long businessId = BaseContext.getCurrentId();

        Business business = businessService.getById(businessId);
        wares.setId(null);
        wares.setStatus(2);
        wares.setCreateTime(LocalDateTime.now());
        wares.setUpdateTime(LocalDateTime.now());
        wares.setCreatePhone(Long.valueOf(business.getPhone()));
        wares.setUpdateId(businessId);


        Boolean aBoolean = waresService.save(wares);
        if (aBoolean){
            return R.success("保存成功");
        }

        return R.success("保存失败");
    }


    /*
     *     查询订单信息
     * */
    @GetMapping("/getOrders")
    public R<List> getOrders(Integer waresId, Integer status, String phone) throws ParseException {

        System.out.println( "id 为：  " + waresId + ",status 为:  " + status + ",phone 为:  " + phone);

        ordersService.initialize();

        long businessId = BaseContext.getCurrentId();

        Business business = businessService.getById(businessId);

        LambdaQueryWrapper<Wares> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Wares::getCreatePhone, business.getPhone());

        List<Wares> waresList = waresService.list(queryWrapper);

        List<Orders> ordersList = new ArrayList<Orders>();

        for (int i = 0; i < waresList.size(); i++) {
            System.out.println("for 循环运行了");
            if ( (waresList.get(i).getId()+"").indexOf((waresId + "")) != -1 || waresId == -1){
            List<Orders> orders = ordersService.getBusinessOrders(null, null, waresList.get(i).getId(),
                    Long.valueOf(phone), null, Integer.valueOf(status));
                System.out.println("orders 的数据是:  " + orders);
            ordersList.addAll(orders);
            }

        }





        return R.success(ordersList);
    }


    /*
     *     修改订单状态
     * */
    @PutMapping("/updateOrders")
    public R<String> updateOrders(@RequestBody Orders orders) throws ParseException {

        System.out.println("orders的数据1是：" + orders);

        LambdaQueryWrapper<Orders> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(orders.getId() != null, Orders::getId, orders.getId());
        Orders orders1 = ordersService.getOne(queryWrapper);

        System.out.println("orders1 的数据是：  " + orders1);

        if (orders1.getStatus() != 1){
            return R.error("该订单已经不是正常状态, 不能更改");
        }


        if (OrdersTime.lastDay(orders1.getUseTime())  && orders.getStatus() != 2) {
            return R.error("已经不能取消订单了，因为距离使用的日期已经不足一天了");
        }

        orders1.setStatus(orders.getStatus());
        orders1.setUpdateTime(LocalDateTime.now());
        ordersService.updateById(orders1);
//        System.out.println("orders的数据2是：" + orders);

//        ordersService.updateById(orders);


        return R.success("修改成功");
    }




    /*
     *     商家修改密码
     * */
    @PostMapping("/changPassword")
    public R<String> changPassword(@RequestBody Map map){
        log.info(map.toString());

        //  获取手机号
        String phone = map.get("phone").toString();

        // 获取验证码
        String code = map.get("code").toString();

        // 获取密码
        String password = map.get("password").toString();

        // 获取密码
        String newPassword = map.get("newPassword").toString();


        // 从 Session 中获取保存的验证码
//        Object codeInSession = session.getAttribute(phone);


        // 从 Redis 中获取缓存的验证码
        Object codeInSession = redisTemplate.opsForValue().get("business_"+phone);



        // 进行验证码的比对(页面提交的验证码和 Session 中保存的验证码比对)
        if (codeInSession != null && codeInSession.equals(code)) {
            // 如果能够比对成功，说明登录成功

            LambdaQueryWrapper<Business> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(Business::getPhone, phone);

            Business business = businessService.getOne(queryWrapper);

            if (business == null) {
                // 判断当前手机号对应的用户是否为新用户，如果是新用户就自动完成注册
/*                business = new business();
                business.setPhone(phone);
                business.setStatus(1);
                businessService.save(business);  */
                return R.error("该员工不存在");

            } else {

                //  1、 将页面提交的密码 password 进行 md5 加密处理
                password = DigestUtils.md5DigestAsHex(password.getBytes());

                //  4、 密码比对，如果不一致则返回登录失败结果
                if (!business.getPassword().equals(password)){
                    return  R.error("密码错误，修改失败");
                }

                //  5、 查看商家状态，如果为已禁用状态，则返回员工已禁用结果
                if (business.getStatus() == 0) {
                    return R.error("该账号已禁用");
                }

                // 新密码加密
                newPassword = DigestUtils.md5DigestAsHex(newPassword.getBytes());

                business.setPassword(newPassword);

                boolean b = businessService.updateById(business);

                if (b){
                    // 如果用户登录成功, 删除 Redis 中缓存的验证码
                    redisTemplate.delete(phone);

                    return R.success("修改成功");
                }


            }


        }

        return R.error("验证码错误,修改失败");
    }







}

